home *** CD-ROM | disk | FTP | other *** search
/ Express Pd: GALORE / Express Pd Galore - The Amiga PD & Shareware CD (1994)(Express Pd)[!][Amiga-CD32-CDTV].iso / productivity / term / termfastmacros.c < prev    next >
C/C++ Source or Header  |  1993-07-16  |  5KB  |  270 lines
  1. /*
  2. **    termFastMacros.c
  3. **
  4. **    Fast! macros support routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel & MXM
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* NewFastMacro(STRPTR Macro,STRPTR Code):
  13.      *
  14.      *    Create a new fast! macro node.
  15.      */
  16.  
  17. struct MacroNode *
  18. NewFastMacro(STRPTR Macro,STRPTR Code)
  19. {
  20.     if(FastMacroCount + 1 < 10000)
  21.     {
  22.         struct MacroNode *Node;
  23.  
  24.         if(Node = (struct MacroNode *)AllocVec(sizeof(struct MacroNode) + 21 + 257,MEMF_ANY|MEMF_CLEAR))
  25.         {
  26.             Node -> mn_Macro    = (STRPTR)(Node + 1);
  27.             Node -> mn_Code        = &Node -> mn_Macro[21];
  28.  
  29.             strcpy(Node -> mn_Macro,Macro);
  30.             strcpy(Node -> mn_Code ,Code);
  31.  
  32.             return(Node);
  33.         }
  34.     }
  35.  
  36.     return(NULL);
  37. }
  38.  
  39.     /* SaveFastMacros(STRPTR Name):
  40.      *
  41.      *    Save the fast! macro list to a file.
  42.      */
  43.  
  44. BYTE
  45. SaveFastMacros(STRPTR Name)
  46. {
  47.     struct IFFHandle    *Handle;
  48.     BYTE             Success = FALSE;
  49.  
  50.     if(Handle = (struct IFFHandle *)AllocIFF())
  51.     {
  52.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  53.         {
  54.             InitIFFasDOS(Handle);
  55.  
  56.             if(!OpenIFF(Handle,IFFF_WRITE))
  57.             {
  58.                 if(!PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN))
  59.                 {
  60.                     if(!PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN))
  61.                     {
  62.                         if(!PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN))
  63.                         {
  64.                             struct TermInfo TermInfo;
  65.  
  66.                             TermInfo . Version    = TermVersion;
  67.                             TermInfo . Revision    = TermRevision;
  68.  
  69.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  70.                             {
  71.                                 if(PopChunk(Handle))
  72.                                     Success = FALSE;
  73.                                 else
  74.                                 {
  75.                                     struct MacroNode *Node;
  76.  
  77.                                     Node = (struct MacroNode *)FastMacroList . lh_Head;
  78.  
  79.                                     while(Node -> mn_Succ)
  80.                                     {
  81.                                         if(!PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN))
  82.                                         {
  83.                                             if(!PushChunk(Handle,0,ID_FAST,IFFSIZE_UNKNOWN))
  84.                                             {
  85.                                                 if(WriteChunkBytes(Handle,Node -> mn_Macro,20) != 20)
  86.                                                 {
  87.                                                     Success = FALSE;
  88.  
  89.                                                     break;
  90.                                                 }
  91.                                                 else
  92.                                                 {
  93.                                                     if(WriteChunkBytes(Handle,Node -> mn_Code,256) != 256)
  94.                                                     {
  95.                                                         Success = FALSE;
  96.  
  97.                                                         break;
  98.                                                     }
  99.                                                     else
  100.                                                     {
  101.                                                         if(PopChunk(Handle))
  102.                                                         {
  103.                                                             Success = FALSE;
  104.  
  105.                                                             break;
  106.                                                         }
  107.                                                         else
  108.                                                             Success = TRUE;
  109.                                                     }
  110.                                                 }
  111.                                             }
  112.  
  113.                                             if(Success)
  114.                                             {
  115.                                                 if(PopChunk(Handle))
  116.                                                 {
  117.                                                     Success = FALSE;
  118.  
  119.                                                     break;
  120.                                                 }
  121.                                             }
  122.                                         }
  123.  
  124.                                         Node = Node -> mn_Succ;
  125.                                     }
  126.                                 }
  127.                             }
  128.                         }
  129.  
  130.                         if(PopChunk(Handle))
  131.                             Success = FALSE;
  132.                     }
  133.  
  134.                     if(PopChunk(Handle))
  135.                         Success = FALSE;
  136.                 }
  137.  
  138.                 CloseIFF(Handle);
  139.             }
  140.  
  141.             Close(Handle -> iff_Stream);
  142.         }
  143.  
  144.         FreeIFF(Handle);
  145.     }
  146.  
  147.     if(Success)
  148.         AddProtection(Name,FIBF_EXECUTE);
  149.     else
  150.         DeleteFile(Name);
  151.  
  152.     return(Success);
  153. }
  154.  
  155.     /* LoadFastMacros(STRPTR Name):
  156.      *
  157.      *    Restore the fast! macro list from a file.
  158.      */
  159.  
  160. BYTE
  161. LoadFastMacros(STRPTR Name)
  162. {
  163.     STATIC ULONG Stops[6] =
  164.     {
  165.         ID_TERM,ID_VERS,
  166.         ID_TERM,ID_FAST,
  167.         ID_TERM,ID_WIND
  168.     };
  169.  
  170.     struct List __aligned     NewFastMacroList;
  171.     LONG             NewFastMacroCount = 0;
  172.     struct IFFHandle    *Handle;
  173.     BYTE             Success = FALSE;
  174.     struct MacroNode    *Node;
  175.     struct ContextNode    *Chunk;
  176.     struct IBox         SizeBox;
  177.  
  178.     NewList(&NewFastMacroList);
  179.  
  180.     if(Handle = AllocIFF())
  181.     {
  182.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  183.         {
  184.             InitIFFasDOS(Handle);
  185.  
  186.             if(!OpenIFF(Handle,IFFF_READ))
  187.             {
  188.                 if(!StopChunks(Handle,Stops,3))
  189.                 {
  190.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  191.                     {
  192.                         Chunk = CurrentChunk(Handle);
  193.  
  194.                         if(Chunk -> cn_ID == ID_VERS)
  195.                         {
  196.                             struct TermInfo TermInfo;
  197.  
  198.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  199.                             {
  200.                                 if((TermInfo . Version > TermVersion) || (TermInfo . Version == TermVersion && TermInfo . Revision > TermRevision) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  201.                                     break;
  202.                             }
  203.                             else
  204.                                 break;
  205.                         }
  206.  
  207.                         if(Chunk -> cn_ID == ID_WIND)
  208.                         {
  209.                             if(ReadChunkBytes(Handle,&SizeBox,sizeof(struct IBox)) == sizeof(struct IBox))
  210.                             {
  211.                                 FastWindowLeft        = SizeBox . Left;
  212.                                 FastWindowTop        = SizeBox . Top;
  213.                                 FastWindowHeight    = SizeBox . Height;
  214.                             }
  215.                             else
  216.                                 break;
  217.                         }
  218.  
  219.                         if(Chunk -> cn_ID == ID_FAST)
  220.                         {
  221.                             if(Node = NewFastMacro("",""))
  222.                             {
  223.                                 if(ReadChunkBytes(Handle,Node -> mn_Macro,20) == 20)
  224.                                 {
  225.                                     if(ReadChunkBytes(Handle,Node -> mn_Code,256) == 256)
  226.                                     {
  227.                                         AddTail(&NewFastMacroList,(struct Node *)Node);
  228.  
  229.                                         NewFastMacroCount++;
  230.  
  231.                                         Success = TRUE;
  232.                                     }
  233.                                     else
  234.                                         break;
  235.                                 }
  236.                                 else
  237.                                     break;
  238.                             }
  239.                             else
  240.                                 break;
  241.                         }
  242.                     }
  243.  
  244.                     if(Success)
  245.                     {
  246.                         if(NewFastMacroList . lh_Head -> ln_Succ)
  247.                         {
  248.                             FreeList(&FastMacroList);
  249.  
  250.                             MoveList(&NewFastMacroList,&FastMacroList);
  251.  
  252.                             FastMacroCount = NewFastMacroCount;
  253.                         }
  254.                     }
  255.                     else
  256.                         FreeList(&NewFastMacroList);
  257.                 }
  258.  
  259.                 CloseIFF(Handle);
  260.             }
  261.  
  262.             Close(Handle -> iff_Stream);
  263.         }
  264.  
  265.         FreeIFF(Handle);
  266.     }
  267.  
  268.     return(Success);
  269. }
  270.